import md5 from 'blueimp-md5'
/**
 * 格式化 attr 数据
 */

/**
 * 生成属性数据
 * @param {Object} v 每个属性的数据源
 * @return {Object} data
 * @return {String} data.name, 属性名
 * @return {String} data.id, 属性 id
 * @return {String} data.is_require, 是否必填
 * @return {String} data.value_type, 该属性的类型： '0': 选择分类，'1'：输入类型
 * @return {String} data.selects, 选中的分类 id
 * @return {Boolean} data.isShow, 是否显示：is_require === '0' && （如果是输入类型 || 选择分类类型的，有分类的）
 * @return {Array<Objcet>} data.classes, 分类数组
 */
export const setAttrData = function(v) {
  const classes = setClassData(v.classes, v.value_type)
  return {
    name: v.name,
    id: v.id,
    is_require: v.is_require,
    value_type: v.value_type,
    selects: [],
    classes,
    type: v.type || '',
    isShow: !!(v.is_require === '0' && ((v.value_type === '0' && classes.length) || v.value_type === '1'))
  }
}

/**
 * 生成分类数据（包括子分类）
 * @param {Array<Object>} v 分类数组
 * @type {Object} object 分类结构
 * @type {String} id 分类 id
 * @type {String} name 分类名
 * @type {Boolean} isShowClass 是否显示二级分类
 * @type {Array<String>} selects 选中的子级分类 id
 * @type {Boolean} isParent 是否父级分类
 * @type {Array<Object>} child 子级分类
 */
const setClassData = function(v, value_type) {
  // 先生成一级分类
  const classes = []
  // 输入类型
  if (value_type === '1') {
    classes[0] = { name: '', id: '' }
    if (v.length) {
      classes[0].name = v.value
      classes[0].id = v.value
    }
    return classes
  }
  v.forEach(v => {
    const pid = v.pid || v.pvalue
    if (pid) return false
    classes.push({
      id: v.id,
      name: v.name,
      isShowClass: false,
      isParent: true,
      selects: [],
      child: []
    })
  })
  // 生成二级分类
  v.forEach(v => {
    const pid = v.pid || v.pvalue
    if (!pid) return false
    classes.some(classesItem => {
      if (pid === classesItem.id) {
        classesItem.child.push({
          id: v.id,
          name: v.name,
          pid
        })
        return true
      }
    })
  })
  return classes
}

/**
 * 根据属性、分类生成 Sku 数据
 * @param {Number} type 该属性的类型，0：预定义，1：自定义
 * @param {Array<object>} attrList 属性数组
 * @param {String} attrId 要添加的属性 id
 * @param {String} classType 该属性 id 下面的分类类型（选中分类还是输入）
 * @param {String} classContent 分类内容
 */
export const createSkuById = function(type, attrList, attrId, classType, classContent) {
  const attr = getAttrById(attrId, attrList)
  if (classType === '1') {
    attr.classes = [{ id: classContent, name: classContent }]
  }
  return {
    ...attr,
    desc: createClassDesc(attr.classes),
    type
  }
}

/**
 * 批量生成 Sku
 * @param {Array<object>} attrList 属性数组
 */
export const createSkus = function(attrList) {
  return attrList.map(v => ({
    ...v,
    value: v.id,
    label: v.name,
    desc: createClassDesc(v.classes),
    type: v.id ? 0 : 1
  }))
}

/**
 * 将 sku 转成参数
 * 如果是输入类型的（type === 1 || (type === 0 && value_type === '1') 的，aValue 的值用 classes 的 name 去赋值
 * @param {Array<object>} skuList sku数组
 */
export const getChangeAttrs = function(skuList) {
  const sku = []
  console.log(skuList)
  skuList.forEach(v => {
    const aId = v.id
    // 自定义属性或者是输入类型的
    if (v.type === 1) {
      v.classes.forEach(classItem => {
        sku.push({ aName: v.name, aValue: classItem.name })
      })
      return
    } else if (v.value_type === '1') {
      v.classes.forEach(classItem => {
        sku.push({ aId, aValue: classItem.name })
      })
      return
    }
    if (v.selects && v.selects.length <= 0) return false
    v.classes.forEach(classItem => {
      // 如果分类 id 不存在 selects 中
      if (!v.selects.includes(classItem.id)) return false
      // 根据属性类型，判断是用 id 还是 name（name 是输入类型）
      sku.push({
        aId,
        aValue: classItem.id
      })
      if (classItem.child && classItem.selects.length > 0) {
        classItem.child.forEach((v2, i2) => {
          // 如果子级分类的 id 不存在分类的 selects 中
          if (!classItem.selects.includes(v2.id)) return false
          sku.push({ aId, aValue: v2.id })
        })
      }
    })
  })
  return sku
}

/**
 * 格式化详情属性数据，转为 attrList 数据结构
 * @param {Array<object>} data 详情属性数据
 */
export const formatDetailDataToAttrList = function(data) {
  const attrTmp = []
  data.forEach(attr => {
    const type = (attr.id || attr.value) ? (attr.type || 0) : 1
    // 属性结构
    const obj = {
      ...attr,
      values: [],
      id: type === 1 ? md5(new Date().getTime()) : attr.id,
      value_type: type === 1 ? '1' : attr.value_type,
      is_require: attr.is_require || '0',
      selects: [],
      type
    }
    const classes = []
    // 筛选一级分类
    attr.values.forEach(classItem => {
      const pid = classItem.pid || classItem.pvalue
      if (pid) return false
      const classesObj = {
        id: classItem.value,
        name: classItem.value_title,
        isParent: true,
        isShowClass: false,
        child: [],
        selects: []
      }
      classes.push(classesObj)
      obj.selects.push(classItem.value)
    })
    // 二级
    attr.values.forEach(classItem => {
      const pid = classItem.pid || classItem.pvalue
      if (!pid) return false
      classes.forEach(v => {
        if (v.id === pid) {
          // 该子级分类属于当前分类
          v.child.push({
            id: classItem.value || classItem.id,
            pid,
            name: classItem.value_title || classItem.name
          })
          v.selects.push(classItem.value)
        }
      })
    })
    // 处理分类
    attrTmp.push({ ...obj, classes })
  })
  return attrTmp
}

/**
 * 将选中的 list (selected 值) 合并到全部的 list 中
 * @param {Array<object>} allList 全部 list
 * @param {Array<object>} selectedList 选中的 list
 */
export const contactAttrData = function(allList, selectedList, type = '') {
  const cache = []
  allList.forEach(attr => {
    selectedList.some(cacheAttr => {
      if (attr.id === cacheAttr.id) {
        if (attr.type === 1 || attr.value_type === '1') {
          // 输入类型
          attr.classes[0] = {
            id: cacheAttr.selects[0],
            name: cacheAttr.selects[0]
          }
          attr.selects = cacheAttr.selects
        } else {
          // 赋值选中的一级分类 id 数组
          attr.selects = cacheAttr.selects
          if (cacheAttr.classes) {
            // 赋值选中的二级分类 id 数组
            attr.classes.forEach(classItem => {
              cacheAttr.classes.some(cacheClassItem => {
                if (classItem.id === cacheClassItem.id) {
                  classItem.selects = cacheClassItem.selects
                  return true
                }
              })
            })
          }
        }
        cache.push(attr)
        return true
      }
    })
  })
  // 再次循环 selectedList，把 type === 0 的找出来（因为` type === 0 的，没有 id）
  selectedList.forEach(v => {
    if (v.type !== 1) return false
    v.classes[0] = {
      id: v.selects[0],
      name: v.selects[0]
    }
    if (type === 'filter') {
      cache.push(v)
    } else {
      allList.push(v)
    }
  })
  console.log(type, 'cache:', cache, 'aliList:', allList, 'selectedList:', selectedList)
  try {
    return JSON.parse(JSON.stringify(type === 'filter' ? cache : allList))
  } catch (error) {
    console.log('转换 json 报错：', error)
    return []
  }
}

/**
 * 根据 id 生成 sku 属性对象（feature）
 */
const getAttrById = function(id, data) {
  const tmp = JSON.parse(JSON.stringify(data.filter(v => v.id === id)[0]))
  // 生成一份新的对象，避免在别的组件修改对象的属性值
  return {
    ...tmp,
    selects: tmp.classes.filter(v => v.isShowClass).map(v => v.id),
    value: tmp.id,
    label: tmp.name
  }
}

/**
 * 根据 class 的 name 值，生成 desc
 */
const createClassDesc = function(data) {
  let str = ''
  data.forEach(classItem => {
    str += classItem.name + ','
    if (!classItem.child) return
    classItem.child.forEach(child => {
      str += child.name + ','
    })
  })
  return str.substring(0, str.length - 1)
}
